Deze handleiding legt uit hoe u uw foto's kunt exporteren van Google Foto's (https://photos.google.com/) en vervolgens kunt importeren in kDrive van Infomaniak.

1. Uw Google-foto's exporteren

Om de foto's die zijn opgeslagen in Google Foto's naar uw computer te halen, gebruikt u Google Takeout. Met deze service kunt u alle items exporteren of alleen bepaalde albums selecteren als u dit in stappen wilt doen:

1. Log in op Google Takeout.
2. Deselecteer alle producten, zodat alleen Google Foto's geselecteerd blijft:
   
3. Selecteer indien nodig de albums die u niet wilt exporteren:
   
4. Ga naar de volgende stap onderaan de pagina:
   
5. Configureer de export in het ZIP-formaat.
6. Klik op de knop Export maken om de export te starten:
   
7. Wacht tot u de e-mail met de downloadlinks ontvangt. Afhankelijk van de hoeveelheid gegevens kan het enkele uren of zelfs dagen duren voordat de export is voltooid.
8. Download de ZIP-archieven en pak ze vervolgens uit op uw computer:
   
9. Groepeer indien nodig de geëxporteerde mappen voordat u ze in kDrive importeert.

2. Corrigeer de datums van de geëxporteerde bestanden

Tijdens een export kunnen de systeembestandsdatums worden vervangen door de exportdatum in plaats van de oorspronkelijke opnamedatum. Als de chronologische volgorde van de foto's na de export niet correct is, kunt u deze datums corrigeren voordat u ze in kDrive importeert.

De onderstaande scripts zoeken naar een datum in deze volgorde: metagegevens van het bestand, het bijbehorende Google Takeout JSON-bestand en vervolgens de datum die in de bestandsnaam staat. Bestanden zonder bruikbare datum worden vermeld in een bestand DateError.txt dat op het bureaublad wordt gemaakt. De gecorrigeerde bestanden worden vermeld in DateFound.txt.

Om het risico op vastlopen bij zeer grote exports te beperken, verwerkt u de bestanden in batches van enkele duizenden items.

Datums corrigeren op macOS

1. Download en installeer ExifTool vanaf https://exiftool.org/index.html door het macOS-pakket te kiezen.
2. Open de applicatie Terminal vanuit de map Programma's > Hulpprogramma's.
3. Kopieer en plak de onderstaande code volledig in Terminal en druk indien nodig op de Enter-toets.
4. Selecteer de map met de geëxporteerde bestanden van Google Takeout.
5. Laat de verwerking voltooien en bekijk vervolgens de bestanden DateFound.txt en DateError.txt die op het bureaublad zijn gemaakt.

Het script dat u volledig moet kopiëren en plakken:

/bin/bash <<'BASH'
#!/bin/bash
set -u

ROOT="$(osascript -e 'POSIX path of (choose folder with prompt "Select the folder containing the files to update")')" || exit 0

DESKTOP="$HOME/Desktop"
LOG_FOUND="$DESKTOP/DateFound.txt"
LOG_ERROR="$DESKTOP/DateError.txt"
: > "$LOG_FOUND"
: > "$LOG_ERROR"

find_exiftool() {
    if command -v exiftool >/dev/null 2>&1; then
        command -v exiftool
        return 0
    fi
    if [ -x "/usr/local/bin/exiftool" ]; then
        printf '%s\n' "/usr/local/bin/exiftool"
        return 0
    fi
    if [ -x "/opt/homebrew/bin/exiftool" ]; then
        printf '%s\n' "/opt/homebrew/bin/exiftool"
        return 0
    fi
    return 1
}

EXIFTOOL="$(find_exiftool)" || {
    printf '%s\n' "ExifTool not found. Install it, then run the script again." >> "$LOG_ERROR"
    printf '%s\n' "ExifTool not found. Check DateError.txt on the desktop."
    exit 1
}

if [ ! -d "$ROOT" ]; then
    printf 'Invalid folder: %s\n' "$ROOT" >> "$LOG_ERROR"
    printf '%s\n' "Invalid folder. Check DateError.txt on the desktop."
    exit 1
fi

get_exif_date() {
    "$EXIFTOOL" -s3 -d "%Y:%m:%d %H:%M:%S" -DateTimeOriginal -CreateDate -MediaCreateDate -TrackCreateDate -CreationDate -ModifyDate -- "$1" 2>/dev/null | awk '/^[0-9]{4}:[0-9]{2}:[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}/ { print substr($0, 1, 19); exit }'
}

get_json_date() {
    local file="$1"
    local json=""
    if [ -f "$file.json" ]; then
        json="$file.json"
    elif [ -f "${file%.*}.json" ]; then
        json="${file%.*}.json"
    fi
    [ -z "$json" ] && return 1

    /usr/bin/perl -MTime::Piece -0777 -ne 'if (/"photoTakenTime"\s*:\s*\{.*?"timestamp"\s*:\s*"([0-9]+)"/s || /"creationTime"\s*:\s*\{.*?"timestamp"\s*:\s*"([0-9]+)"/s) { print localtime($1)->strftime("%Y:%m:%d %H:%M:%S"); }' "$json"
}

get_name_date() {
    local name
    name="$(basename "$1")"
    if [[ "$name" =~ ([12][0-9]{3})[-_]?([01][0-9])[-_]?([0-3][0-9])([_\ -]?([0-2][0-9])[-_\.]?([0-5][0-9])[-_\.]?([0-5][0-9]))? ]]; then
        local year="${BASH_REMATCH[1]}"
        local month="${BASH_REMATCH[2]}"
        local day="${BASH_REMATCH[3]}"
        local hour="12"
        local minute="00"
        local second="00"
        if [ -n "${BASH_REMATCH[5]:-}" ]; then
            hour="${BASH_REMATCH[5]}"
            minute="${BASH_REMATCH[6]}"
            second="${BASH_REMATCH[7]}"
        fi
        printf '%s:%s:%s %s:%s:%s\n' "$year" "$month" "$day" "$hour" "$minute" "$second"
        return 0
    fi
    return 1
}

is_valid_date() {
    date -j -f "%Y:%m:%d %H:%M:%S" "$1" "+%Y:%m:%d %H:%M:%S" >/dev/null 2>&1
}

to_touch_date() {
    printf '%s' "$1" | sed -E 's/^([0-9]{4}):([0-9]{2}):([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})$/\1\2\3\4\5.\6/'
}

write_metadata() {
    local file="$1"
    local date_value="$2"
    "$EXIFTOOL" -overwrite_original "-DateTimeOriginal=$date_value" "-CreateDate=$date_value" "-ModifyDate=$date_value" -- "$file" >/dev/null 2>&1 || true
}

process_file() {
    local file="$1"
    local date_value=""
    local source=""

    date_value="$(get_exif_date "$file")"
    if [ -n "$date_value" ]; then
        source="EXIF"
    else
        date_value="$(get_json_date "$file")"
        if [ -n "$date_value" ]; then
            source="Google Takeout JSON"
        else
            date_value="$(get_name_date "$file")"
            if [ -n "$date_value" ]; then
                source="file name"
            fi
        fi
    fi

    if [ -n "$date_value" ] && is_valid_date "$date_value"; then
        local touch_value
        touch_value="$(to_touch_date "$date_value")"
        if [ "$source" != "EXIF" ]; then
            write_metadata "$file" "$date_value"
        fi
        if touch -t "$touch_value" "$file" 2>/dev/null; then
            printf '%s | %s | %s\n' "$source" "$date_value" "$file" >> "$LOG_FOUND"
        else
            printf 'Unable to update file date: %s\n' "$file" >> "$LOG_ERROR"
        fi
    else
        printf 'No valid date found: %s\n' "$file" >> "$LOG_ERROR"
    fi
}

while IFS= read -r -d '' file; do
    case "$file" in
        *.json|*_original) continue ;;
    esac
    process_file "$file"
done < <(find "$ROOT" -type f -print0)

printf '%s\n' "Done. Check DateFound.txt and DateError.txt on the desktop."
BASH

Datums corrigeren in Windows

1. Download ExifTool van https://exiftool.org/index.html en kies het Windows-uitvoerbare bestand.
2. Plaats het in een toegankelijke map, bijvoorbeeld C:\ExifTool.
3. Hernoem het bestand exiftool(-k).exe naar exiftool.exe.
4. Controleer of het volledige pad correct is: C:\ExifTool\exiftool.exe.
   • Als u ExifTool op een andere locatie plaatst, wijzig dan de eerste regel van de configuratie in het onderstaande script.
5. Kopieer en plak het onderstaande script in Kladblok.
6. Sla het bestand op met de extensie .ps1, bijvoorbeeld UpdateExifDates.ps1.
7. Klik met de rechtermuisknop op het .ps1-bestand en voer het uit met PowerShell.
8. Selecteer de map met de bestanden die zijn geëxporteerd vanuit Google Takeout.
9. Laat het verwerkingsproces voltooien en bekijk vervolgens de bestanden DateFound.txt en DateError.txt die op het bureaublad zijn gemaakt.

Het script dat u volledig moet kopiëren en plakken:

# === Configuration ===
$ExifToolPath = "C:\ExifTool\exiftool.exe"
$Desktop = [Environment]::GetFolderPath("Desktop")
$LogFound = Join-Path $Desktop "DateFound.txt"
$LogError = Join-Path $Desktop "DateError.txt"
Set-Content -Path $LogFound -Value ""
Set-Content -Path $LogError -Value ""

if (-not (Test-Path -LiteralPath $ExifToolPath)) {
    Add-Content -Path $LogError -Value "ExifTool not found: $ExifToolPath"
    Write-Host "ExifTool not found. Check the path in the script."
    exit
}

# === Folder selection dialog ===
Add-Type -AssemblyName System.Windows.Forms
$FolderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog
$FolderBrowser.Description = "Select the folder to process"
if ($FolderBrowser.ShowDialog() -ne [System.Windows.Forms.DialogResult]::OK) { exit }
$Folder = $FolderBrowser.SelectedPath

function Get-DateFromExif {
    param ([string]$FilePath)

    $Tags = @("DateTimeOriginal", "CreateDate", "MediaCreateDate", "TrackCreateDate", "CreationDate", "ModifyDate")
    foreach ($Tag in $Tags) {
        $Value = (& $ExifToolPath "-$Tag" -s3 -d "%Y:%m:%d %H:%M:%S" -- "$FilePath" 2>$null | Select-Object -First 1)
        if ($Value -match '^(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})') {
            try {
                return [datetime]::ParseExact($Matches[0], "yyyy:MM:dd HH:mm:ss", [Globalization.CultureInfo]::InvariantCulture)
            } catch {}
        }
    }
    return $null
}

function Get-DateFromJson {
    param ([string]$FilePath)

    $JsonPaths = @("$FilePath.json", [System.IO.Path]::ChangeExtension($FilePath, ".json")) | Select-Object -Unique
    foreach ($JsonPath in $JsonPaths) {
        if (Test-Path -LiteralPath $JsonPath) {
            try {
                $Json = Get-Content -LiteralPath $JsonPath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
                $Timestamp = $null
                if ($Json.photoTakenTime -and $Json.photoTakenTime.timestamp) {
                    $Timestamp = [int64]$Json.photoTakenTime.timestamp
                } elseif ($Json.creationTime -and $Json.creationTime.timestamp) {
                    $Timestamp = [int64]$Json.creationTime.timestamp
                }

                if ($null -ne $Timestamp) {
                    return ([DateTimeOffset]::FromUnixTimeSeconds($Timestamp)).LocalDateTime
                }
            } catch {}
        }
    }
    return $null
}

function Get-DateFromFileName {
    param ([string]$FileName)

    if ($FileName -match '([12]\d{3})[-_]?(0[1-9]|1[0-2])[-_]?(0[1-9]|[12]\d|3[01])(?:[ _-]?([01]\d|2[0-3])[-_.]?([0-5]\d)[-_.]?([0-5]\d))?') {
        $Year = $Matches[1]
        $Month = $Matches[2]
        $Day = $Matches[3]
        $Hour = "12"
        $Minute = "00"
        $Second = "00"

        if ($Matches[4]) {
            $Hour = $Matches[4]
            $Minute = $Matches[5]
            $Second = $Matches[6]
        }

        $DateString = "$Year$Month$Day$Hour$Minute$Second"
        try {
            return [datetime]::ParseExact($DateString, "yyyyMMddHHmmss", [Globalization.CultureInfo]::InvariantCulture)
        } catch {}
    }
    return $null
}

function Write-Metadata {
    param (
        [string]$FilePath,
        [datetime]$DateValue
    )

    $ExifDate = $DateValue.ToString("yyyy:MM:dd HH:mm:ss", [Globalization.CultureInfo]::InvariantCulture)
    & $ExifToolPath -overwrite_original "-DateTimeOriginal=$ExifDate" "-CreateDate=$ExifDate" "-ModifyDate=$ExifDate" -- "$FilePath" 2>$null | Out-Null
}

function Set-FileDates {
    param (
        [string]$FilePath,
        [datetime]$DateValue
    )

    [System.IO.File]::SetCreationTime($FilePath, $DateValue)
    [System.IO.File]::SetLastWriteTime($FilePath, $DateValue)
    [System.IO.File]::SetLastAccessTime($FilePath, $DateValue)
}

Get-ChildItem -LiteralPath $Folder -Recurse -File | Where-Object {
    $_.Extension -ne ".json" -and $_.Name -notlike "*_original"
} | ForEach-Object {
    $File = $_
    $FilePath = $File.FullName
    $DateValue = Get-DateFromExif -FilePath $FilePath
    $Source = "EXIF"

    if (-not $DateValue) {
        $DateValue = Get-DateFromJson -FilePath $FilePath
        $Source = "Google Takeout JSON"
    }

    if (-not $DateValue) {
        $DateValue = Get-DateFromFileName -FileName $File.Name
        $Source = "file name"
    }

    if ($DateValue) {
        try {
            if ($Source -ne "EXIF") {
                Write-Metadata -FilePath $FilePath -DateValue $DateValue
            }
            Set-FileDates -FilePath $FilePath -DateValue $DateValue
            Add-Content -Path $LogFound -Value "$Source | $($DateValue.ToString('yyyy-MM-dd HH:mm:ss')) | $FilePath"
        } catch {
            Add-Content -Path $LogError -Value "Unable to update file date: $FilePath"
        }
    } else {
        Add-Content -Path $LogError -Value "No valid date found: $FilePath"
    }
}

[System.Windows.Forms.MessageBox]::Show("Done. Check DateFound.txt and DateError.txt on the desktop.")

3. Foto's importeren in kDrive

Zodra uw bestanden klaar zijn, kunt u ze importeren via de web-app kDrive, mits het aantal bestanden en uw internetverbinding het uploaden via de browser mogelijk maken:

1. Ga naar de web-app kDrive van Infomaniak.
2. Open de locatie waar de foto's moeten worden geïmporteerd.
3. Klik op de knop ‍ Nieuw linksboven.
4. Klik op Map importeren.
5. Selecteer de map met uw foto's op uw computer.
6. Wacht tot het importeren is voltooid. Het activiteitenlogboek wordt rechtsonder weergegeven:
   

Als u de kDrive-desktopapp gebruikt, kunt u de map met uw foto's ook in de structuur van uw kDrive-map op de computer plaatsen. De synchronisatie start dan automatisch en de bestanden worden naar de Infomaniak-servers verzonden.

4. Toegang tot foto's vanaf uw apparaten

Zodra het importeren of de synchronisatie is voltooid, kunt u uw foto's benaderen vanaf de apparaten die zijn verbonden met uw kDrive.

• In de web-app kDrive kunt u de weergave aanpassen om de miniaturen te vergroten en uw foto's gemakkelijker te bekijken: