Diese Anleitung erklärt, wie Sie Ihre Fotos von Google Fotos (https://photos.google.com/) exportieren und anschließend in kDrive von Infomaniak importieren.

1. Ihre Google-Fotos exportieren

Um Ihre in Google Fotos gespeicherten Fotos auf Ihrem Computer zu speichern, verwenden Sie Google Takeout. Mit diesem Dienst können Sie entweder alle Elemente exportieren oder nur bestimmte Alben auswählen, wenn Sie dies schrittweise vornehmen möchten:

1. Melden Sie sich bei Google Takeout an.
2. Deaktivieren Sie die Auswahl aller Produkte, sodass nur Google Fotos ausgewählt ist:
   
3. Wählen Sie gegebenenfalls die Alben aus, die nicht exportiert werden sollen:
   
4. Gehen Sie zum nächsten Schritt am unteren Rand der Seite:
   
5. Konfigurieren Sie den Export im ZIP-Format.
6. Klicken Sie auf die Schaltfläche Export erstellen, um den Export zu starten:
   
7. Warten Sie, bis Sie die E-Mail mit den Download-Links erhalten. Je nach Datenmenge kann die Vorbereitung des Exports mehrere Stunden oder sogar Tage dauern.
8. Laden Sie die ZIP-Archive herunter und entpacken Sie sie auf Ihrem Computer:
   
9. Gruppieren Sie die exportierten Ordner gegebenenfalls, bevor Sie sie in kDrive importieren.

2. Datumsangaben der exportierten Dateien korrigieren

Beim Export können die Systemdatumsangaben der Dateien durch das Exportdatum anstelle des ursprünglichen Aufnahmedatums ersetzt werden. Wenn die chronologische Reihenfolge der Fotos nach dem Export nicht korrekt ist, können Sie diese Datumsangaben vor dem Import in kDrive korrigieren.

Die folgenden Skripte suchen in dieser Reihenfolge nach einem Datum: Metadaten der Datei, zugehörige Google Takeout-JSON-Datei und dann das Datum, das im Dateinamen enthalten ist. Dateien, bei denen kein verwendbares Datum gefunden werden kann, werden in einer Datei DateError.txt auf dem Desktop aufgelistet. Die korrigierten Dateien werden in DateFound.txt aufgelistet.

Um das Risiko von Blockaden bei sehr großen Exporten zu minimieren, verarbeiten Sie die Dateien in Batches von einigen Tausend Elementen.

Datumsangaben unter macOS korrigieren

1. Laden Sie ExifTool von https://exiftool.org/index.html herunter und installieren Sie es, indem Sie das macOS-Paket auswählen.
2. Öffnen Sie die Anwendung Terminal im Ordner Programme > Dienstprogramme.
3. Kopieren Sie den folgenden Block vollständig in das Terminal und bestätigen Sie ihn gegebenenfalls mit der Eingabetaste.
4. Wählen Sie den Ordner aus, der die von Google Takeout exportierten Dateien enthält.
5. Warten Sie, bis die Verarbeitung abgeschlossen ist, und überprüfen Sie dann die auf dem Desktop erstellten Dateien DateFound.txt und DateError.txt.

Das Skript, das vollständig kopiert und eingefügt werden soll:

/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

Datumsangaben unter Windows korrigieren

1. Laden Sie ExifTool von https://exiftool.org/index.html herunter, indem Sie die Windows-Version auswählen.
2. Legen Sie die Datei in einem zugänglichen Ordner ab, z. B. C:\ExifTool.
3. Benennen Sie die Datei exiftool(-k).exe in exiftool.exe um.
4. Vergewissern Sie sich, dass der vollständige Pfad C:\ExifTool\exiftool.exe lautet.
   • Wenn Sie ExifTool an einem anderen Ort ablegen, ändern Sie die erste Konfigurationszeile des folgenden Skripts.
5. Kopieren Sie das folgende Skript in den Editor.
6. Speichern Sie die Datei mit der Erweiterung .ps1, z. B. UpdateExifDates.ps1.
7. Klicken Sie mit der rechten Maustaste auf die Datei .ps1 und führen Sie sie mit PowerShell aus.
8. Wählen Sie den Ordner aus, der die von Google Takeout exportierten Dateien enthält.
9. Warten Sie, bis die Verarbeitung abgeschlossen ist, und überprüfen Sie dann die auf dem Desktop erstellten Dateien DateFound.txt und DateError.txt.

Das vollständige Skript zum Kopieren und Einfügen:

# === 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. Fotos in kDrive importieren

Sobald Ihre Dateien bereit sind, können Sie sie über die Web-App kDrive importieren, wenn die Anzahl der Dateien und Ihre Internetverbindung das Hochladen über den Browser ermöglichen:

1. Rufen Sie die Web-App kDrive von Infomaniak auf.
2. Öffnen Sie den Speicherort, in den die Fotos importiert werden sollen.
3. Klicken Sie auf die Schaltfläche ‍ Neu oben links.
4. Klicken Sie auf Ordner importieren.
5. Wählen Sie den Ordner mit Ihren Fotos auf Ihrem Computer aus.
6. Warten Sie, bis der Import abgeschlossen ist. Das Aktivitätsprotokoll wird unten rechts angezeigt:
   

Wenn Sie die Desktop-App kDrive verwenden, können Sie den Ordner mit Ihren Fotos auch in der Ordnerstruktur Ihres kDrive-Ordners auf dem Computer platzieren. Die Synchronisierung startet dann automatisch und die Dateien werden auf die Infomaniak-Server übertragen.

4. Zugriff auf Fotos von Ihren Geräten aus

Sobald der Import oder die Synchronisierung abgeschlossen ist, können Sie von allen mit Ihrem kDrive verbundenen Geräten auf Ihre Fotos zugreifen.

• In der Web-App kDrive können Sie die Anzeige ändern, um die Miniaturansichten zu vergrößern und Ihre Fotos einfacher zu durchsuchen: