Jtdylktuy

I have a script that was working before I started breaking it apart into smaller pieces. Something I noticed is as I try and use variables the information is not brought in. I have to copy paste that variable into my If, Else, While, or other functions in order for them to be used. I was told to use $script: but as far as I can tell that only allows the variable to "report out" of the function to be used later. I don't need that just to pull the info in.

Breakdown of my script thus far:

1. User drops a folder into a specific drop off folder.


2. The script detects a new file and starts to run


3. The name of the folder is noted


4. All the files are moved from their folder structure into another folder.


5. All those files are then converted to a single .pdf


6. That .pdf is moved to a "completed folder"


7. All the empty folders and files are deleted.

The script runs all this upon startup, then sits and watches for updates.

My code:

#File Locations

$rootPath = 'C:IT'

$inLoc = 'Convert Drop'

$prossLoc = 'Processing'

$outLoc = 'Converted PDF'



#File types to include in PDF creation.

$fileTypes = '*.{png,jpeg,jpg,tiff,tif}'



#Function Variables

$inPath  = Join-Path -Path "$rootPath" -ChildPath "$inLoc"

$outPath = Join-Path -Path "$rootPath" -ChildPath "$outLoc"

$runPath = Join-Path -Path "$rootPath" -ChildPath "$prossLoc"

$remove1 = Join-Path -Path "$rootPath" -ChildPath "$($inLoc + "*")"

$remove2 = Join-Path -Path "$rootPath" -ChildPath "$($outLoc + "*")"



#Folder Watching Variables

$watcher = New-Object System.IO.FileSystemWatcher

$watcher.Path = "$inPath"

$watcher.Filter = "*.*"

$watcher.IncludeSubdirectories = $false

$watcher.EnableRaisingEvents = $true



#Lone Counter

$freshStart = $null

$statusOld  = $null

$pathLoc    = (Get-Item -Path ".").FullName



#Pulls the last write time of a folder to compare later.

$grabStatus = {$status = Get-Item $pathLoc | Foreach { $_.LastWriteTime } }



#Get PDF name from Folder

$grabFileName = {

    $folder = get-childitem -Path $inPath -Directory -Name

    $fileName = $folder + ".pdf"

}



#Move all nested files to single folder.

$moveFiles = {

    Get-ChildItem -Path $inPath -Recurse -File | Move-Item -Destination $runPath

}



#Convert Nested files into single PDF

$makePDF = {

    & CD $runPath

    & magick "$fileTypes" $fileName

}



#Move final PDF

$moveCmplt = {

    Get-ChildItem -Path $pdf -File | Move-Item -Destination $outPath

}



#Delete Old files

$deleteOld = {

    Remove-Item $remove1 -Recurse -Force

    Remove-Item $remove2 -Recurse -Force

}



#Set compare status to current status then fetches new status.

$stats = {

    $statusOld = $status

    $grabStatus

    sleep 10

}



#Exicute main conversion together.

$action = {

    $grabStatus

    If ($status -eq $statusOld){

        $grabFileName

        $moveFiles

        & CD $runPath

        $grabStatus

        If ($status -eq $statusOld) {

            $makePDF

        }

        Else{

            $stats

        }

        $deleteOld

    }

    Else

    {

        $stats

    }

}



#First Time Start, Then Loop run.

While ($freshStart -eq $null) {

    If ((Get-ChildItem $inPath | Measure-Object).Count -eq 0) {

    }

    Else {

        $action

    }

    $freshStart = "FreshStartDone!"

}



#Scan folder every 5 seconds for new content then run convert on change.

Register-ObjectEvent $watcher "Created" -Action $action

while ($true) {sleep 5}

UPDATED CODE
It works on the first time run, but the loop is broken after converting everything to functions.

#File Locations

$rootPath = 'C:IT'

$inLoc = 'Convert Drop'

$prossLoc = 'Processing'

$outLoc = 'Converted PDF'



#File types to include in PDF creation.

$fileTypes = '*.{png,jpeg,jpg,tiff,tif}'



#Function Variables

$inPath = Join-Path -Path "$rootPath" -ChildPath "$inLoc"

$outPath = Join-Path -Path "$rootPath" -ChildPath "$outLoc"

$runPath = Join-Path -Path "$rootPath" -ChildPath "$prossLoc"

$remove1 = Join-Path -Path "$rootPath" -ChildPath "$($inLoc + "*")"

$remove2 = Join-Path -Path "$rootPath" -ChildPath "$($prossLoc + "*")"



#Folder Watching Variables

$watcher = New-Object System.IO.FileSystemWatcher

$watcher.Path = "$inPath"

$watcher.Filter = "*.*"

$watcher.IncludeSubdirectories = $true

$watcher.EnableRaisingEvents = $true



#Lone Vars

$freshStart = $null

$statusOld = $null

$pathLoc = (Get-Item -Path ".").FullName

#$pathMagick = 'C:Program FilesImageMagick-7.0.8-Q16magick.exe'



#Pulls the last write time of a folder to compare later.

function grabStatus

{

    & CD $runPath

    $status = Get-Item $pathLoc | Foreach { $_.LastWriteTime }

}



#Get PDF name from Folder

function grabFileName

{

    $folder = get-childitem -Path $inPath -Directory -Name

    $global:fileName = $folder + ".pdf"

}



#Move all nested files to single folder.

function moveFiles

{

    Get-ChildItem -Path $inPath -Recurse -File | Move-Item -Destination $runPath

}



#Convert Nested files into single PDF

function makePDF

{

    & CD $runPath

    & magick $fileTypes $global:fileName

}



#Move final PDF

function moveCmplt

{

    Get-ChildItem -Path "$runPath*.pdf" -File | Move-Item -Destination $outPath

}



#Delete Old files

function deleteOld

{

    Remove-Item $remove1 -Recurse -Force

    Remove-Item $remove2 -Recurse -Force

}



#Set compare status to current status then fetches new status.

function stats

{

    $statusOld = $status

    $grabStatus

    sleep 10

}



#Exicute main conversion together.

function action

{

    grabStatus

    If ($status -eq $statusOld)

    {

        grabFileName

        moveFiles

        grabStatus

        If ($status -eq $statusOld)

        {

            makePDF

            grabStatus

            If ($status -eq $statusOld)

            {

                grabStatus

                moveCmplt

                If ($status -eq $statusOld)

                {

                    deleteOld

                }

            }

            Else { stats }

        }

        Else { stats }

    }

    Else { stats }

}



$runIt = { action }



#First Time Start, Then Loop run.

While ($freshStart -eq $null)

{

    If ((Get-ChildItem $inPath | Measure-Object).Count -eq 0)

    {

    }

    Else

    {

        action

    }

    $freshStart = "FreshStartDone!"

}



#Scan folder every 5 seconds for new content then run convert on change.

Register-ObjectEvent $watcher "Created" -Action $runIt

#Register-ObjectEvent $watcher "Created" -Action $action

while ($true) { sleep 5 }

Summed up solution:

Converted my script blocks to functions
i.e.

$variable = {code}

to

function variable {code}

This worked for most of my script but the uninteded side affect was that my loop no longer worked. The solution for that was to convert the main function I was using to a global function.
i.e.

function global:functionName {code}

After this everything is working exactly how it should. Thank you Pimp Juice IT, LPChip, and HackSlash for all your help.

Working Script:

#File Locations

$rootPath = 'C:IT'

$inLoc    = 'Convert_Drop'

$prossLoc = 'Processing'

$outLoc   = 'Converted PDF'



#File types to include in PDF creation.

$fileTypes = '*.{png,jpeg,jpg,tiff,tif}'



#Function Variables

$inPath  = Join-Path -Path "$rootPath" -ChildPath "$inLoc"

$outPath = Join-Path -Path "$rootPath" -ChildPath "$outLoc"

$runPath = Join-Path -Path "$rootPath" -ChildPath "$prossLoc"

$remove1 = Join-Path -Path "$rootPath" -ChildPath "$($inLoc + "*")"

$remove2 = Join-Path -Path "$rootPath" -ChildPath "$($prossLoc + "*")"



#Folder Watching Variables

$watcher = New-Object System.IO.FileSystemWatcher

$watcher.Path = "$inPath"

$watcher.Filter = "*.*"

$watcher.IncludeSubdirectories = $true

$watcher.EnableRaisingEvents = $true



#Lone Vars

$freshStart = $null

$statusOld = $null

$pathLoc = (Get-Item -Path ".").FullName



#Pulls the last write time of a folder to compare later.

function grabStatus

{

    & CD $runPath

    $status = Get-Item $pathLoc | Foreach { $_.LastWriteTime }

}



#Get PDF name from Folder

function grabFileName

{

    $folder = get-childitem -Path $inPath -Directory -Name

    $global:fileName = $folder + ".pdf"

}



#Move all nested files to single folder.

function moveFiles

{

    Get-ChildItem -Path $inPath -Recurse -File | Move-Item -Destination $runPath

}



#Convert Nested files into single PDF

function makePDF

{

    & CD $runPath

    & magick $fileTypes $global:fileName

}



#Move final PDF

function moveCmplt

{

    Get-ChildItem -Path "$runPath*.pdf" -File | Move-Item -Destination $outPath

}



#Delete Old files

function deleteOld

{

    Remove-Item $remove1 -Recurse -Force

    Remove-Item $remove2 -Recurse -Force

}



#Set compare status to current status then fetches new status.

function stats

{

    $statusOld = $status

    $grabStatus

    sleep 10

}



#Exicute main conversion together.

function global:runIt

{

    grabStatus

    If ($status -eq $statusOld)

    {

        grabFileName

        moveFiles

        grabStatus

        If ($status -eq $statusOld)

        {

            makePDF

            grabStatus

            If ($status -eq $statusOld)

            {

                grabStatus

                moveCmplt

                If ($status -eq $statusOld)

                {

                    deleteOld

                }

            }

            Else { stats }

        }

        Else { stats }

    }

    Else { stats }

}



#$runIt = { action }



#First Time Start, Then Loop run.

While ($freshStart -eq $null)

{

    If ((Get-ChildItem $inPath | Measure-Object).Count -eq 0)

    {

    }

    Else

    {

        global:runIt

    }

    $freshStart = "FreshStartDone!"

}



#Scan folder every 5 seconds for new content then run convert on change.

Register-ObjectEvent $watcher "Created" -Action { global:runIt }

while ($true) { sleep 5 }

As with most programming/script languages, variables have a scope. They can share data within the main code, or function, but not cross that boundary unless you tell the script it can do so.

Although you can use global variables to set something globally, you can also work with functions if you do it well. Let me explain.

Functions can get variables from outside the script and return them to the caller of the function. Powershell does functions a bit different than most scripts, because it treats a function as an object, which allows you to do cool things.

Here is a small example of how to use a function with multiple variables:

function Tools

{



    param

    (   [switch]$MySwitch

    ,   [switch]$MySwitchWithReturn

    ,   [Parameter(Mandatory=$false)] [String] $MyParameter

    )





    if( $MySwitch )

    {

        write-host "My Switch was activated"

    }



    if( $MySwitchWithReturn )

    {

        "My SwitchWithReturn was activated"

    }



    if( $MyParameter )

    {

        Write-Host "The parameter has value: " + $MyParameter

        $MyValue2 = "Another value, 2"



        #Lets return 2 different values.

        "Value with nr 1"

        $MyValue2

    }

}



Tools -MySwitch



$MyVar = Tools -MySwitchWithReturn

write-host "MyVar contains: " + $MyVar



$ReturnValues = Tools -MyParameter "test"



Write-host "The first value is: " + $ReturnValues[0]

Write-host "The second value is: " + $ReturnValues[1]

This returns:

My Switch was activated

MyVar contains: + My SwitchWithReturn was activated

The parameter has value: + test

The first value is: + Value with nr 1

The second value is: + Another value, 2

To recap the above, the param section is used to allow lots of control on how parameters can be passed to a function. This is not the only way, but allows for really cool things, so it is my preferred method.

To give anything back to the section that called the function, simply print it out to console. By typing "a string" or just typing the name of a variable as shown in the MyParameter section.

Lastly, if you want to quickly do something, here's an example of working with global variables. This is useful if you want to have a settings section at the top of your script:

$Global:MySetting = "This string is globally available."



Write-Host "Accessing the global: " + $Global:MySetting



function MyFunction ($MyParameter)

{

    write-host "My Parameter is:" + $MyParameter

    write-host "The global string is: " + $Global:MySetting

}



MyFunction "testing"

This returns:

Accessing the global: + This string is globally available.

My Parameter is: + testing

The global string is: + This string is globally available.

I hope this helps you. If not, please leave a comment. :)

According to this Microsoft document about variable scope you need to declare the variable scope:

https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scopes?view=powershell-5.1

EXAMPLE:
To create the same variable in the script scope, use the script scope modifier:

$script:a = "one"

The "report out" scope you are talking about would be "global". That makes the variable available outside of your script.