# Create local variables
$ReportServiceWarnings = $null
$ReportName = $ReportFile.SubString($ReportFile.LastIndexOf("\") + 1)
$ReportName = $ReportName.SubString(0, $ReportName.IndexOf("."))

# Upload report
Write-Host "Uploading $ReportName"
$Result = $ReportServerProxy.CreateCatalogItem("Report", $ReportName, $ReportFolder, $true, $ReportData, $null, [ref] $ReportServiceWarnings);

# load the xml
[xml]$ReportXml = Get-Content $ReportFile

# retrieve the datasource nodes
$DataSourceReferenceNodes = $ReportXml.GetElementsByTagName("DataSourceReference")

# loop through returned results
foreach($Node in $DataSourceReferenceNodes)
{
    # store the name
    $DataSourceNames += $Node.InnerText
}

# return the results
return ,$DataSourceNames # Apparently using the , in front of the variable is how you return explicit arrays in PowerShell ... could you be more obsure?

# fill in properties
$SearchCondition.Condition = Get-SpecificEnumValue -EnumNamespace "$ReportServerProxyNamespace.ConditionEnum" -EnumName "Equals"
$SearchCondition.ConditionSpecified = $true
$SearchCondition.Name = "Name"
$SearchCondition.Values = @($ItemName)

# search
$items = $ReportServerProxy.FindItems($ItemFolderPath, (Get-SpecificEnumValue -EnumNamespace "$ReportServerProxyNamespace.BooleanOperatorEnum" -EnumName "And"), $null, $SearchCondition)

# check to see if anything was returned
if($items.Length -gt 0)
{
    # return true
    #return $true

    # loop through returned items
    foreach($item in $items)
    {
        # check the path
        if($item.Path -eq "$ItemFolderPath/$ItemName")
        {
            # return true
            return $true
        }
    }

    # items were found, but the path doesn't match
    return $false
}
else
{
    return $false
}

# get the datasources
$DataSources = $ReportServerProxy.GetItemDataSources([string]::Format("{0}/{1}", $ReportFolder, $ReportName))

#loop through retrieved datasources
foreach($DataSource in $DataSources)
{
    # check to make sure the datasource exists in the location specified
    if((Item-Exists -ItemFolderPath $ReportDatasourceFolder -ItemName $DataSource.Name) -eq $true)
    {
        # create datasource reference variable
        $DataSourceReference = New-Object "$ReportServerProxyNamespace.DataSourceReference";

        # assign
        $DataSourceReference.Reference = "$ReportDatasourceFolder/" + $DataSource.Name
        $DataSource.Item = $DataSourceReference
    }
    else
    {
        # get the datasource name to include in warning message -- I know there must be a way to use the property in a string literal, but I wasn't able to figure it out while trying
        # to solve a reported bug so I took the easy way.
        $DataSourceName = $DataSource.Name

        # display warning
        Write-Warning "Warning - unable to find datasource $DataSourceName in $ReportDataSourceFolder"

        # update to false
        $AllDataSourcesFound = $false
    }
}

# check to see if found all datasources
if($AllDataSourcesFound -eq $true)
{
    Write-Host "Associating datasources to $ReportFolder/$ReportName"

    # save the references
    $ReportServerProxy.SetItemDataSources("$ReportFolder/$ReportName", $DataSources)
}

# Loop through to find the specific value
foreach($EnumValue in $EnumValues)
{
    # check current
    if($EnumValue -eq $EnumName)
    {
        # return it
        return $EnumValue
    }
}

# nothing was found
return $null

# necessary so that when attempting to use the report execution service, it doesn't puke on you when it can't find the data source
$ReportData = (Remove-Datasources -ReportFile $ReportFile)

# get just the report name
$ReportName = $ReportFile.SubString($ReportFile.LastIndexOf("\") + 1)
$ReportName = $ReportName.SubString(0, $ReportName.IndexOf("."))

# create warnings object
$ReportExecutionWarnings = $null

# load the report definition
$ExecutionInfo = $ReportExecutionProxy.LoadReportDefinition($ReportData, [ref] $ReportExecutionWarnings);

# loop through the report execution parameters
foreach($Parameter in $ExecutionInfo.Parameters)
{
    # create new item parameter object
    $ItemParameter = New-Object "$ReportServerProxyNamespace.ItemParameter";

    # fill in the properties except valid values, that one needs special processing
    Copy-ObjectProperties -SourceObject $Parameter -TargetObject $ItemParameter;

    # fill in the valid values
    $ItemParameter.ValidValues = Convert-ValidValues -SourceValidValues $Parameter.ValidValues;

    # add to list
    $ReportParameters += $ItemParameter;
}

# force the parameters to update
Write-Host "Updating report parameters for $ReportFolder/$ReportName"
$ReportServerProxy.SetItemParameters("$ReportFolder/$ReportName", $ReportParameters);

# read xml
[xml]$ReportXml = Get-Content $ReportFile;

# create new memory stream object
$MemoryStream = New-Object System.IO.MemoryStream

try
{
    # get all datasource nodes
    $DatasourceNodes = $ReportXml.GetElementsByTagName("DataSourceReference");

    $NodesToRemove = @();

    # loop through returned nodes
    foreach($DataSourceNode in $DatasourceNodes)
    {
        # create a new connection properties node
        $ConnectionProperties = $ReportXml.CreateNode($DataSourceNode.NodeType, "ConnectionProperties", $null);

        # create a new dataprovider node
        $DataProvider = $ReportXml.CreateNode($DataSourceNode.NodeType, "DataProvider", $null);
        $DataProvider.InnerText = "SQL";

        # create new connection string node
        $ConnectString = $ReportXml.CreateNode($DataSourceNode.NodeType, "ConnectString", $null);
        $ConnectString.InnerText = "Data Source=Server Name Here;Initial Catalog=database name here";

        # add new node to parent node
        [void] $DataSourceNode.ParentNode.AppendChild($ConnectionProperties);

        # append childeren
        [void] $ConnectionProperties.AppendChild($DataProvider);
        [void] $ConnectionProperties.AppendChild($ConnectString);

        # Add to remove list
        $NodesToRemove += $DataSourceNode;
    }

    # loop through nodes to remove
    foreach($Node in $NodesToRemove)
    {
        # remove from parent
        [void] $Node.ParentNode.RemoveChild($Node);
    }

    $ReportXml.InnerXml = $ReportXml.InnerXml.Replace("xmlns=`"`"", "")

    # save altered xml to memory stream
    $ReportXml.Save($MemoryStream);

    # return the altered xml as byte array
    return $MemoryStream.ToArray();
}

# get the destination
$TargetPropertyCollection = $TargetObject.GetType().GetProperties();

# loop through source property collection

    # check to see if it's null
    if($TargetProperty -ne $null)
    {
        # check to see if it's the valid values property
        if($TargetProperty.Name -ne "ValidValues")
        {
             # set the value
            $TargetProperty.SetValue($TargetObject, $SourcePropertyCollection[$i].GetValue($SourceObject));
        }
    }
}

# loop through source values
foreach($SourceValidValue in $SourceValidValues)
{
    # create target valid value object
    $TargetValidValue = New-Object "$ReportServerProxyNamespace.ValidValue";

    # copy properties
    Copy-ObjectProperties -SourceObject $SourceValidValue -TargetObject $TargetValidValue

    # add to list
    $TargetValidValues += $TargetValidValue
}

# return the values
return ,$TargetValidValues

# check to see if the item exists
if((Item-Exists -ItemFolderPath $ReportFolder -ItemName $ReportName) -eq $true)
{
    # get file extension
    $ReportExtension = [System.IO.Path]::GetExtension($ReportFile)

    # check backuplocation
    if($BackupLocation.EndsWith("\") -ne $true)
    {
        # append ending slash
        $BackupLocation = $BackupLocation + "\"
    }

    # ensure the backup location actually exists
    if((Test-Path $BackupLocation) -ne $true)
    {
        # create it
        New-Item -ItemType Directory -Path $BackupLocation
    }

    # download the item
    $Item = $ReportServerProxy.GetItemDefinition("$ReportFolder/$ReportName")

    # form the backup path
    $BackupPath = "{0}{1}{2}" -f $BackupLocation, $ReportName, $ReportExtension;

    # write to disk
    [System.IO.File]::WriteAllBytes("$BackupPath", $Item);

    # write to screen
    Write-Host "Backed up $ReportFolder/$ReportName to $BackupPath";
}

# get all report files for deployment
Write-Host "Getting all .rdl files"
Get-ChildItem $DeployedPath -Recurse -Filter "*.rdl" | ForEach-Object { If(($ReportFiles -contains $_.FullName) -eq $false) {$ReportFiles += $_.FullName}}

# set the report proxies
Write-Host "Creating SSRS Web Service proxies"
$ReportServerProxy = New-WebServiceProxy -Uri $ReportServerUrl -UseDefaultCredential
$ReportExecutionProxy = New-WebServiceProxy -Uri $ReportExecutionUrl -UseDefaultCredential

# get the service proxy namespaces - this is necessary because of a bug documented here http://stackoverflow.com/questions/7921040/error-calling-reportingservice2005-finditems-specifically-concerning-the-bool and http://www.vistax64.com/powershell/273120-bug-when-using-namespace-parameter-new-webserviceproxy.html
$ReportServerProxyNamespace = Get-ObjectNamespace -Object $ReportServerProxy
$ReportExecutionProxyNamespace = Get-ObjectNamespace -Object $ReportExecutionProxy

# get the proxy auto generated name spaces

# loop through array
foreach($ReportFile in $ReportFiles)
{
    # check to see if we need to back up
    if($BackupLocation -ne $null -and $BackupLocation -ne "")
    {
        # backup the item
        Backup-ExistingItem -ReportFile $ReportFile
    }

    # upload report
    Upload-Report $ReportFile

    # extract datasources
    #Write-Host "Extracting datasource names for $ReportFile"
    #$ReportDataSourceNames = Get-ReportDataSourceNames $ReportFile

    # set the datasources
    #Set-ReportDataSources -ReportDataSourceNames $ReportDataSourceNames -ReportFile $ReportFile
    Set-ReportDataSources -ReportFile $ReportFile

    # update the report parameters
    Update-ReportParameters -ReportFile $ReportFile
}

if($ReportExecutionProxy -ne $null)
{
    # dispose
    $ReportExecutionProxy.Dispose();
}