Check-ImageDownloads.ps1

<#
.SYNOPSIS
    Reports how many pictures in a OneNote notebook have actually been downloaded to
    this computer, so you know when it is worth running the export.

.DESCRIPTION
    OneNote keeps page text on your machine but fetches the pictures only when it
    needs them. A picture that has not been downloaded comes back with no format,
    and the exporter cannot save it -- that is what "could not be saved" means in
    the export summary.

    Ticking "Download all files and images" tells OneNote to fetch them all, but it
    does that quietly in the background and never says when it has finished. This
    script counts them so you can tell.

        Run it            -> see how many are still missing
        Run it again      -> see whether the number is going down
        When it hits zero -> run the export

    Use -Recheck after the first run to re-test only the pages that were missing
    pictures, which is much faster than scanning everything again.

    Use -Nudge to walk OneNote through those pages, which makes it fetch the
    pictures on that page there and then. This is slower but does not rely on the
    background download getting there on its own.

    MUST run under Windows PowerShell 5.1, in a normal (non-Administrator) window --
    same as Export-OneNoteMarkdown.ps1.

.PARAMETER Notebook
    Notebook name. Omit to pick from a list.

.PARAMETER Recheck
    Only re-test the pages that were short of pictures last time. Fast.

.PARAMETER Nudge
    Open each page that is short of pictures so OneNote downloads them now.

.EXAMPLE
    Right-click this file in File Explorer and choose "Run with PowerShell".

.EXAMPLE
    powershell.exe -NoProfile -File .\Check-ImageDownloads.ps1 -Notebook "Sales Notebook" -Recheck
#>
[CmdletBinding()]
param(
    [string] $Notebook,
    [switch] $Recheck,
    [switch] $Nudge,
    [int]    $NudgeWaitMs = 1500
)

Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'

$script:HS_PAGES   = 4  # HierarchyScope.hsPages
$script:PI_BASIC   = 0  # PageInfo.piBasic
$script:XS_CURRENT = 1

$script:InteractiveRun = -not $PSBoundParameters.ContainsKey('Notebook')

function Wait-ForUser {
    if (-not $script:InteractiveRun) { return }
    Write-Host ''
    try { Read-Host 'Press Enter to close this window' | Out-Null } catch { }
}

trap {
    Write-Host ''
    Write-Host '-----------------------------------------------------------' -ForegroundColor Red
    Write-Host ' Stopped before finishing.' -ForegroundColor Red
    Write-Host '-----------------------------------------------------------' -ForegroundColor Red
    Write-Host ''
    Write-Host $_.Exception.Message -ForegroundColor Yellow
    Wait-ForUser
    exit 1
}

function Assert-Environment {
    if ($PSVersionTable.PSVersion.Major -ne 5) {
        throw @"
This must run under Windows PowerShell 5.1, not PowerShell $($PSVersionTable.PSVersion).
OneNote cannot be reached from 7.x.

Re-run with:
  powershell.exe -NoProfile -File "$PSCommandPath"
"@
    }
    $principal = New-Object Security.Principal.WindowsPrincipal(
        [Security.Principal.WindowsIdentity]::GetCurrent())
    if ($principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
        throw @"
This window is running as Administrator. OneNote cannot be reached from an elevated
process. Close it and open a normal PowerShell window instead.
"@
    }
}

function Get-OneNoteApp {
    for ($attempt = 1; $attempt -le 4; $attempt++) {
        try { return New-Object -ComObject OneNote.Application }
        catch {
            if ($attempt -eq 4) { throw "Could not attach to OneNote: $($_.Exception.Message)" }
            Start-Sleep -Seconds ($attempt * 2)
        }
    }
}

function Get-Attr {
    param($Node, [string] $Name, [string] $Default = '')
    if ($null -eq $Node) { return $Default }
    $a = $Node.Attributes.GetNamedItem($Name)
    if ($null -eq $a) { return $Default }
    return $a.Value
}

function Get-SafeName {
    param([string] $Name)
    $safe = $Name
    foreach ($c in [System.IO.Path]::GetInvalidFileNameChars()) { $safe = $safe.Replace($c, '-') }
    return ($safe -replace '\s+', '-')
}

# ---------------------------------------------------------------------------

Assert-Environment

Write-Host ''
Write-Host 'OneNote picture download check' -ForegroundColor Cyan
Write-Host '------------------------------' -ForegroundColor Cyan

$app = Get-OneNoteApp
[ref]$hierarchyXml = ''
$app.GetHierarchy('', $script:HS_PAGES, $hierarchyXml)
$hierarchy = [xml]$hierarchyXml.Value

$allNotebooks = @($hierarchy.SelectNodes("/*/*[local-name()='Notebook']"))
if ($allNotebooks.Count -eq 0) {
    throw 'No notebooks are open in OneNote. Open the one you want to check, then run this again.'
}

$chosen = $null
if ($Notebook) {
    $chosen = $allNotebooks | Where-Object { (Get-Attr $_ 'name') -eq $Notebook } | Select-Object -First 1
    if (-not $chosen) {
        $chosen = $allNotebooks | Where-Object { (Get-Attr $_ 'name') -like $Notebook } | Select-Object -First 1
    }
    if (-not $chosen) {
        $names = ($allNotebooks | ForEach-Object { '  - ' + (Get-Attr $_ 'name') }) -join "`r`n"
        throw "No notebook called '$Notebook'. Open notebooks are:`r`n$names"
    }
}
else {
    Write-Host ''
    Write-Host 'Which notebook do you want to check?' -ForegroundColor Green
    Write-Host ''
    for ($i = 0; $i -lt $allNotebooks.Count; $i++) {
        Write-Host ('  {0,2}. {1}' -f ($i + 1), (Get-Attr $allNotebooks[$i] 'name'))
    }
    Write-Host ''
    while ($null -eq $chosen) {
        $answer = Read-Host "Type a number from 1 to $($allNotebooks.Count) and press Enter"
        if ($answer -match '^\s*(\d+)\s*$') {
            $pick = [int]$Matches[1]
            if ($pick -ge 1 -and $pick -le $allNotebooks.Count) { $chosen = $allNotebooks[$pick - 1] }
        }
        if ($null -eq $chosen) { Write-Host "  '$answer' is not one of the numbers above." -ForegroundColor Yellow }
    }
}

$nbName = Get-Attr $chosen 'name' 'Notebook'
Write-Host ''
Write-Host "Checking: $nbName" -ForegroundColor Green

$stateFile = Join-Path $PSScriptRoot ("_image-status-{0}.json" -f (Get-SafeName $nbName))

# Which pages to test: everything, or just the ones that were short last time.
$pages = @($chosen.SelectNodes(".//*[local-name()='Page']"))
$pageById = @{}
foreach ($p in $pages) { $pageById[(Get-Attr $p 'ID')] = $p }

$targets = $pages
if ($Recheck) {
    if (-not (Test-Path -LiteralPath $stateFile)) {
        Write-Host ''
        Write-Host 'No previous check found, so this run will scan everything.' -ForegroundColor Yellow
    }
    else {
        $prior = Get-Content -LiteralPath $stateFile -Raw | ConvertFrom-Json
        $priorIds = @($prior.PendingPageIds)
        $targets = @($priorIds | ForEach-Object { $pageById[$_] } | Where-Object { $_ })
        if ($targets.Count -eq 0) {
            Write-Host ''
            Write-Host '-----------------------------------------------------------' -ForegroundColor Green
            Write-Host ' Nothing left to re-check.' -ForegroundColor Green
            Write-Host '-----------------------------------------------------------' -ForegroundColor Green
            Write-Host ''
            Write-Host "  Every picture in $nbName was already downloaded at the last" -ForegroundColor Green
            Write-Host "  full check ($($prior.Ready) of $($prior.TotalImages)). Run the export." -ForegroundColor Green
            Write-Host ''
            Write-Host '  To scan the whole notebook again, run without -Recheck.'
            Wait-ForUser
            exit 0
        }
        Write-Host ''
        Write-Host "Re-checking only the $($targets.Count) page(s) that were short of pictures last time." -ForegroundColor Cyan
    }
}

Write-Host ''
Write-Host "$($targets.Count) page(s) to look at. Please leave OneNote alone while this runs." -ForegroundColor Yellow
if (-not $Recheck -and $targets.Count -gt 800) {
    Write-Host ("Roughly {0:n0} minute(s) for a full check. Use -Recheck next time for a quick one." -f `
        [Math]::Ceiling($targets.Count * 0.12 / 60)) -ForegroundColor Yellow
}
Write-Host ''

$totalImages = 0
$ready       = 0
$pendingIds  = New-Object System.Collections.ArrayList
$bySection   = @{}
$n = 0
$sw = [System.Diagnostics.Stopwatch]::StartNew()

foreach ($pg in $targets) {
    $n++
    $pageId = Get-Attr $pg 'ID'
    $title  = Get-Attr $pg 'name' 'Untitled'
    $secName = 'Unknown section'
    if ($pg.ParentNode) { $secName = Get-Attr $pg.ParentNode 'name' 'Unknown section' }

    if ($n % 5 -eq 0 -or $n -eq $targets.Count) {
        $eta = ''
        if ($n -gt 20) {
            $per = $sw.Elapsed.TotalSeconds / $n
            $eta = ' | about {0:hh\:mm\:ss} left' -f [TimeSpan]::FromSeconds($per * ($targets.Count - $n))
        }
        Write-Progress -Activity 'Checking pictures' -Status "$n/$($targets.Count)$eta" `
            -CurrentOperation $title -PercentComplete ([int](100 * $n / [Math]::Max($targets.Count, 1)))
    }

    if ($Nudge) {
        try { $app.NavigateTo($pageId, '', $false); Start-Sleep -Milliseconds $NudgeWaitMs } catch { }
    }

    [ref]$raw = ''
    try { $app.GetPageContent($pageId, $raw, $script:PI_BASIC, $script:XS_CURRENT) } catch { continue }

    $doc = [xml]$raw.Value
    $pagePending = 0
    foreach ($img in $doc.SelectNodes("//*[local-name()='Image']")) {
        $totalImages++
        # An image OneNote has not fetched yet reports no format, and its bytes
        # cannot be read (GetBinaryPageContent fails with 0x8004200F).
        if ([string]::IsNullOrWhiteSpace((Get-Attr $img 'format'))) { $pagePending++ }
        else { $ready++ }
    }

    if ($pagePending -gt 0) {
        [void]$pendingIds.Add($pageId)
        if (-not $bySection.ContainsKey($secName)) { $bySection[$secName] = 0 }
        $bySection[$secName] += $pagePending
    }

    if ($n % 250 -eq 0) { [GC]::Collect() }
}

Write-Progress -Activity 'Checking pictures' -Completed
$sw.Stop()

$pending = $totalImages - $ready

# Keep the page list so -Recheck can be quick next time.
@{
    Notebook       = $nbName
    CheckedUtc     = (Get-Date).ToUniversalTime().ToString('o')
    TotalImages    = $totalImages
    Ready          = $ready
    Pending        = $pending
    PendingPageIds = @($pendingIds)
} | ConvertTo-Json -Depth 3 | Set-Content -LiteralPath $stateFile -Encoding UTF8

Write-Host ''
Write-Host '-----------------------------------------------------------' -ForegroundColor Green
Write-Host ' Result' -ForegroundColor Green
Write-Host '-----------------------------------------------------------' -ForegroundColor Green
Write-Host ''
Write-Host ('  Pictures found        {0:n0}' -f $totalImages)
Write-Host ('  Downloaded, ready     {0:n0}' -f $ready)
Write-Host ('  Still missing         {0:n0}' -f $pending)
if ($totalImages -gt 0) {
    Write-Host ('  Complete              {0:n1}%' -f (100 * $ready / $totalImages))
}
Write-Host ('  Time taken            {0:hh\:mm\:ss}' -f $sw.Elapsed)
Write-Host ''

if ($pending -eq 0 -and $totalImages -gt 0) {
    Write-Host '  All pictures are downloaded. Run the export now.' -ForegroundColor Green
}
elseif ($pending -gt 0) {
    Write-Host '  Sections still waiting on pictures:' -ForegroundColor Yellow
    $bySection.GetEnumerator() | Sort-Object Value -Descending | Select-Object -First 8 |
        ForEach-Object { Write-Host ('    {0,6:n0}  {1}' -f $_.Value, $_.Key) -ForegroundColor Yellow }
    Write-Host ''
    Write-Host '  Leave OneNote open and connected, then check again with:' -ForegroundColor Yellow
    Write-Host ("    powershell.exe -NoProfile -File `"$PSCommandPath`" -Notebook `"$nbName`" -Recheck") -ForegroundColor Yellow
    Write-Host ''
    Write-Host '  If the number is not going down, make OneNote fetch them directly:' -ForegroundColor Yellow
    Write-Host ("    powershell.exe -NoProfile -File `"$PSCommandPath`" -Notebook `"$nbName`" -Recheck -Nudge") -ForegroundColor Yellow
}

Wait-ForUser